`:top
`!Ruby`! (englisch für `*`F33f`_`[Rubin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rubin]`_`f`*) ist eine `F33f`_`[höhere Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Höhere_Programmiersprache]`_`f, die Mitte der 1990er Jahre vom Japaner `F33f`_`[Yukihiro Matsumoto`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Yukihiro_Matsumoto]`_`f entworfen wurde.
Ruby ist `F33f`_`[objektorientiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f, unterstützt aber mehrere weitere `F33f`_`[Programmierparadigmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierparadigma]`_`f (unter anderem `F33f`_`[prozedurale`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozedurale_Programmierung]`_`f und `F33f`_`[funktionale Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionale_Programmierung]`_`f sowie `F33f`_`[Nebenläufigkeit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Nebenläufigkeit]`_`f), bietet `F33f`_`[dynamische Typisierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dynamische_Typisierung]`_`f, `F33f`_`[Reflexion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Reflexion_(Programmierung)]`_`f und `F33f`_`[automatische Speicherbereinigung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Automatische_Speicherbereinigung]`_`f. Ein Programm in Ruby wird zur Laufzeit `F33f`_`[interpretiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interpreter]`_`f. 2012 wurde die Ruby-Spezifikation als internationale Norm ISO/IEC 30170 standardisiert.`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f]
>>Contents
• `F0af`_`[Entstehung und Geschichte`#entstehung-und-geschichte]`_`f
• `F0af`_`[Merkmale`#merkmale]`_`f
• `F0af`_`[Alles ist ein Objekt`#alles-ist-ein-objekt]`_`f
• `F0af`_`[Blöcke`#bl-cke]`_`f
• `F0af`_`[Mixins`#mixins]`_`f
• `F0af`_`[Domänenspezifische Sprache`#dom-nenspezifische-sprache]`_`f
• `F0af`_`[Mächtige Standardbibliothek`#m-chtige-standardbibliothek]`_`f
• `F0af`_`[Metaprogrammierung`#metaprogrammierung]`_`f
• `F0af`_`[Integration in Unix`#integration-in-unix]`_`f
• `F0af`_`[Syntax und Grundlagen`#syntax-und-grundlagen]`_`f
• `F0af`_`[Bestandteile`#bestandteile]`_`f
• `F0af`_`[Interaktive Ruby-Shell`#interaktive-ruby-shell]`_`f
• `F0af`_`[RDoc und ri`#rdoc-und-ri]`_`f
• `F0af`_`[Rake`#rake]`_`f
• `F0af`_`[Paketverwaltung`#paketverwaltung]`_`f
• `F0af`_`[Implementierungen`#implementierungen]`_`f
• `F0af`_`[Referenzimplementierung`#referenzimplementierung]`_`f
• `F0af`_`[Alternative Implementierungen`#alternative-implementierungen]`_`f
• `F0af`_`[Verbreitung und Einsatz`#verbreitung-und-einsatz]`_`f
• `F0af`_`[Kritik`#kritik]`_`f
• `F0af`_`[Sonstiges`#sonstiges]`_`f
• `F0af`_`[Nutzungsbedingungen`#nutzungsbedingungen]`_`f
• `F0af`_`[RubyForge`#rubyforge]`_`f
• `F0af`_`[Literatur`#literatur]`_`f
• `F0af`_`[Normen und Standards`#normen-und-standards]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f
-─
>>Entstehung und Geschichte
Yukihiro „Matz“ Matsumoto begann 1993 an einer eigenen Sprache zu arbeiten und gab am 21. Dezember 1995 die erste Version von Ruby, 0.95, frei.`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] Den Namen, hergeleitet vom `F33f`_`[Edelstein`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schmuckstein]`_`f `F33f`_`[Rubin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rubin]`_`f, wählte er als Anspielung auf die Programmiersprache `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f] Matsumotos Ziel bei der Erschaffung der neuen Sprache war, eine Synthese aus Elementen der von ihm geschätzten Programmiersprachen `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f, `F33f`_`[Smalltalk`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Smalltalk_(Programmiersprache)]`_`f, `F33f`_`[Eiffel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eiffel_(Programmiersprache)]`_`f, `F33f`_`[Ada`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ada_(Programmiersprache)]`_`f und `F33f`_`[Lisp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lisp]`_`f zu bilden und `F33f`_`[funktionale`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionale_Programmierung]`_`f und `F33f`_`[imperative`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Imperative_Programmierung]`_`f `F33f`_`[Programmierparadigmen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierparadigma]`_`f in Einklang zu bringen. Darüber hinaus sollte die Sprache `F33f`_`[objektorientierter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f als `F33f`_`[Python`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Python_(Programmiersprache)]`_`f und zugleich mächtiger als `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f sein. Auch Flexibilität, Ausdrucksstärke und Einfachheit spielten bereits eine gewichtige Rolle.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]
Besonders wichtig, neben den technischen Eigenschaften, war Matsumoto an Ruby auch die emotionale Wirkung auf Anwender, Mitentwickler und sich selbst. Matsumotos Auffassung dazu ist folgende:
`*„Natürlich unterscheidet sich Ruby von Perl oder Python an vielen Stellen, das ist schließlich Rubys Daseinsberechtigung. Rubys wesentliches Ziel ist „Freude“. Meines Wissens gibt es keine andere Sprache, die sich so sehr auf die Freude konzentriert. Rubys eigentliches Ziel ist es zu erfreuen – Sprachdesigner, Anwender, Sprachlerner, jeden. Freude allein ist jedoch nicht alles. Ruby bietet auch viele Verwendungsmöglichkeiten. Könnte man sie nicht einsetzen, würde sie doch auch keine Freude bereiten.“`*
–
Yukihiro Matsumoto
:
Vorwort des Sprachschöpfers in „Rubyプログラミング入門“ (übersetzt)
In `F33f`_`[Japan`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Japan]`_`f erlangte Ruby nach Erscheinen rasch an Bekanntheit. Im `F33f`_`[Westen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Westliche_Welt]`_`f verhalfen der Programmiersprache das Buch `*Programming Ruby`* (2000) (bekannt als `*Pickaxe book`* als Anspielung auf die Illustration auf dem Buchdeckel) und das `F33f`_`[Webframework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webframework]`_`f `*`F33f`_`[Ruby on Rails`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ruby_on_Rails]`_`f`* (2004) zum Durchbruch. In den folgenden Jahren mehrte sich auch die englisch- und deutschsprachige Dokumentation sowie Literatur. Die Verkehrssprache der Kern-Entwickler wechselte von Japanisch zu Englisch. Heute wird die Sprache als `F33f`_`[Open-Source`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open_Source]`_`f-Projekt weitergepflegt und ist Gegenstand diverser Publikationen und Kurse. Veröffentlichungen mit neuen Funktionen geschehen üblicherweise im Jahresrhythmus zur Weihnachtszeit.
Ein Meilenstein in der Entwicklung von Ruby war die Version 1.9 im Jahr 2007, welche mit vielen Änderungen ziemlich inkompatibel zu den Vorgängerversionen wurde. Die Semantik einiger Konstrukte hat sich in dieser Version geändert.`:cite-ref-8[`F5bf`_`[8`#cite-note-8]`_`f] Der `F33f`_`[Interpreter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interpreter]`_`f wurde komplett neu geschrieben, womit Rubyprogramme wesentlich schneller wurden. Zeichenketten bekamen separate `F33f`_`[Zeichenkodierungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeichenkodierung]`_`f, Variablen in Blöcken wurden block-lokal, `F33f`_`[IPv6`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IPv6]`_`f-Unterstützung und einige syntaktische Erleichterungen fanden Einzug.
Mit Ruby 2.0 wurden `F33f`_`[Schlüsselwortparameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parameter_(Informatik)]`_`f eingeführt (bspw.: `B100`F9d90.step(by: 5, to: 20)`f`b), das Vorhängen `*(prepend)`* von Modulen und `F33f`_`[Bedarfsauswertung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Lazy_Evaluation]`_`f `*(lazy-evaluation)`* von Iteratoren eingeführt. Außerdem wurde die `F33f`_`[Standardzeichenkodierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeichenkodierung]`_`f auf `F33f`_`[UTF-8`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=UTF-8]`_`f festgelegt. Ruby 2.1 führte `*Refinements`* (eine Methode um Überschreibungen von Klassen lokal zu beschränken) ein. In Ruby 2.2 wurde der vorhandene `F33f`_`[Garbage-Collector`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Garbage_Collection]`_`f durch einen inkrementellen ersetzt. Mit Ruby 2.3 ist es möglich, alle Zeichenketten automatisch schreibgeschützt zu erstellen und ein neuer Operator `B100`F9d9&.`f`b `*(Safe-Navigation-Operator)`* zum Umgehen von Nil-Überprüfungen wurde eingeführt. In Ruby 2.4 wurden die Klassen `*Fixnum`* und `*Bignum`* vereinheitlicht. Seit Ruby 2.5 können `F33f`_`[Exceptions`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ausnahmebehandlung]`_`f in `*do-end`*-Blöcken ohne separate Unterblöcke gefangen werden. Ruby 2.6 lieferte den ersten Code eines optionalen `F33f`_`[JIT-Compilers`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Just-in-time-Kompilierung]`_`f und fügte `*Bundler`* (s. u.) zur Standarddistribution hinzu. Ruby 2.7 führte ausführliches Patternmatching und einige syntaktische Erleichterungen dem Sprachkern hinzu. Jede neue Ruby-Version ab 1.9 brachte zudem Geschwindigkeitsoptimierungen verschiedenen Ausmaßes mit sich. Zusätzlich erweiterte jede Version die `F33f`_`[Standardbibliothek`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standardbibliothek]`_`f um nützliche Methoden. Es wurde stets auf `F33f`_`[Abwärtskompatibilität`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kompatibilität_(Technik)]`_`f geachtet, allerdings nicht immer zu hundert Prozent erreicht.
Ruby 3.0, erschienen am 25. Dezember 2020, ist die erste Version, welche die „Ruby 3x3“ genannten Forderungen erfüllt: Dreimal höhere Ausführungsgeschwindigkeit zu Ruby 2.0 (durch JIT-Compiler), Nebenläufigkeit ohne GIL (allerdings noch experimentell) und statische Typanalyse (optional). Das eigentliche Update 3.0 stellt allerdings keinen größeren Sprung als die vorherigen jährlichen Veröffentlichungen dar und ist abwärtskompatibel zu Ruby 2.x.
>>Merkmale
>>>Alles ist ein Objekt
Ruby ist eine Programmiersprache, die, obwohl sie auch viele andere Programmierparadigmen unterstützt, von Grund auf objektorientiert ist. Das bedeutet konkret, dass in Ruby ausnahmslos jeder Wert ein Objekt und jede Funktion eine Methode ist (d. h. einer Klasse zugeordnet ist). Ausnahmen für `F33f`_`[primitive Datentypen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Datentyp]`_`f wie in vielen anderen objektorientierten Programmiersprachen gibt es nicht. Auch Klassen sind Objekte. Objekte speichern Instanzvariablen und haben eine Klasse. Klassen sind Objekte, die Methoden speichern und eine Vererbungshierarchie besitzen. Auf Instanzvariablen kann ausschließlich über Methoden zugegriffen werden.
`B100`F9d9class TestKlasse`f`b
`B100`F9d9end`f`b
`B100`F9d9test_objekt = TestKlasse.new`f`b
`B100`F9d9`f`b
`B100`F9d9puts 1.class # => Integer`f`b
`B100`F9d9puts "text".class # => String`f`b
`B100`F9d9puts test_objekt.class # => TestKlasse`f`b
`B100`F9d9puts TestKlasse.class # => Class`f`b
`B100`F9d9puts Class.class # => Class`f`b
Werden in Ruby „Funktionen“ definiert, so sind das in Wirklichkeit Methoden, die dem Objekt `*Object`* hinzugefügt werden. In Ruby erben alle Objekte implizit von `*Object`*, weswegen so definierte „Funktionen“ in jedem Objekt und damit allgegenwärtig verfügbar sind. Allerdings werden diese Funktionen als `*private`* markiert, das heißt, sie können nicht von außen auf einem Objekt aufgerufen werden.
`B100`F9d9# Definiere „Funktion“`f`b
`B100`F9d9def meine_funktion`f`b
`B100`F9d9 puts "Hier bin ich"`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9# Kann in andern Objekten wie eine Funktion benutzt werden`f`b
`B100`F9d9class ABC`f`b
`B100`F9d9 def gib_meine_funktion_aus`f`b
`B100`F9d9 meine_funktion`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9mein_abc = ABC.new`f`b
`B100`F9d9mein_abc.gib_meine_funktion_aus # => Hier bin ich`f`b
`B100`F9d9mein_abc.meine_funktion # => Fehlermeldung, private method \`meine_funktion' called`f`b
Da in Ruby Objekte dynamisch sind, kann man mit Ruby auch prototypbasiert programmieren. Das bedeutet grob, dass Objekte eigene Methoden haben können (außerhalb der von der Klasse vorgegebenen) und kopiert und verändert werden können (da nur Klassen Methoden beinhalten können, wird im Hintergrund eine versteckte neue Klasse nur für das eine Objekt angelegt).
`B100`F9d9auto1 = Object.new`f`b
`B100`F9d9def auto1.beschleunigen`f`b
`B100`F9d9 puts "brumm brumm brumm"`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9auto1.beschleunigen # => "brumm brumm brumm"`f`b
`B100`F9d9`f`b
`B100`F9d9auto2 = auto1.clone`f`b
`B100`F9d9def auto2.bremsen`f`b
`B100`F9d9 puts "quietsch"`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9auto2.beschleunigen # => "brumm brumm brumm"`f`b
`B100`F9d9auto2.bremsen # => "quietsch"`f`b
>>>Blöcke
In den meisten höheren Programmiersprachen ist es möglich, Funktionen in irgendeiner Form zusätzlich als Parameter Logik zu übergeben, sei es durch `F33f`_`[First-Class-Funktionen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=First-Class-Funktion]`_`f oder `F33f`_`[First-Class-Objekte`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=First-Class-Objekt]`_`f (deren Methoden dann die Logik bereitstellen). Das ist in Ruby nicht anders, allerdings hat Ruby den Spezialfall, dass genau eine Funktion übergeben wird, syntaktisch (und auch von der Rechenleistung) stark optimiert. Dieser Spezialfall wird `*Block`* genannt, gemeint als ein Block Programmierlogik, den die Funktion zu benutzen hat.
Blöcke werden Funktionen als separate Parameter übergeben und folgen als letztes Argument, eingegrenzt durch geschwungene Klammern oder die Schlüsselworte `*do`* und `*end`*. Im Folgenden wird die Methode `*times`* des Objekts 10 aufgerufen und ein Block übergeben. Beide Aufrufe sind identisch.
`B100`F9d910.times {`f`b
`B100`F9d9 puts "Hallo Welt!"`f`b
`B100`F9d9}`f`b
`B100`F9d910.times do`f`b
`B100`F9d9 puts "Hallo Welt!"`f`b
`B100`F9d9end`f`b
Zusätzlich können Blöcken Parameter übergeben werden und sie haben auch einen Rückgabewert. Zum Aufrufen des übergebenen Blocks wird innerhalb der aufgerufenen Methode das Schlüsselwort `*yield`* verwendet. Werden nach `*yield`* Parameter angegeben, so werden diese dem Block übergeben, der sie zu Beginn als lokale Variablen deklarieren oder ignorieren kann. Blöcke (ebenso wie Methoden) geben automatisch den letzten Ausdruck des Blockes als Rückgabewert zurück (mittels `*break`* und `*next`* kann aber auch an anderen Stellen zurückgesprungen werden).
`B100`F9d9def methode_die_block_aufruft(übergebener_parameter)`f`b
`B100`F9d9 eigene_variable = "Hallo"`f`b
`B100`F9d9 rückgabe = yield eigene_variable, übergebener_parameter`f`b
`B100`F9d9 if rückgabe == "ok"`f`b
`B100`F9d9 puts "☺"`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9# Aufruf`f`b
`B100`F9d9methode_die_block_aufruft("aus Ruby") do |p1,p2| # die Blockargumente werden innerhalb || in Block-lokale Variablen umgewandelt`f`b
`B100`F9d9 puts p1 + " " + p2 + "!"`f`b
`B100`F9d9 "ok"`f`b
`B100`F9d9end`f`b
`B100`F9d9# Zuerst wird im Block „Hallo aus Ruby!“ ausgegeben,`f`b
`B100`F9d9# dann in der Methode ☺, da der Rückgabewert „ok“ war`f`b
Blöcke können auch in Funktionsobjekte umgewandelt werden. Wird innerhalb der Parameterliste einer Methode vor den letzten Parameter ein & geschrieben, wandelt Ruby den übergebenen Block in ein `*Proc`* (ein Funktions-Objekt) um. Alternativ können Procs auch manuell durch die Schlüsselworte `*proc`*, `*lambda`* und `*->`* angelegt werden. Aufgerufen werde diese Objekte durch die Methoden `*call`*, `*[]`* oder `*.()`*. Da Ruby runde Klammern lediglich zum Gruppieren nutzt, können Procs nicht (wie in anderen Programmiersprachen üblich) mit `B100`F9d9proc_name()`f`b aufgerufen werden.
`B100`F9d9def mache_block_zu_proc &block`f`b
`B100`F9d9 block # ist der Rückgabewert, da letzter Ausdruck`f`b
`B100`F9d9end`f`b
`B100`F9d9a = mache_block_zu_proc{|a,b| a + b}`f`b
`B100`F9d9b = proc {|a,b| a - b} # ein return innerhalb des Blocks verlässt die beinhaltende Methode, break nur den Block`f`b
`B100`F9d9c = lambda {|a,b| a * b} # wie proc, aber return innerhalb des lambdas verlässt nur diesen Block`f`b
`B100`F9d9d = -> (a,b) {a / b} # neue Schreibweise für lambda, runde Klammern sind optional`f`b
`B100`F9d9a.call(1,2) # => 3`f`b
`B100`F9d9b[1,2] # => -1`f`b
`B100`F9d9c.(1,2) # => 2`f`b
`B100`F9d9`f`b
`B100`F9d9# Beispiel für funktionale Programmierung`f`b
`B100`F9d9e = d.curry.(8) # neues Proc das den (oder die) ersten Parameter (den Dividenden hier) als 8 setzt`f`b
`B100`F9d9e.(2) # => 4`f`b
`B100`F9d9# mit & können Proc-Objekte (eigentlich jede Klasse, die eine "call"-Methode hat) wieder in Blöcke umgewandelt werden`f`b
`B100`F9d9[8,4,2,1].map(&e) # => [1, 2, 4, 8]`f`b
Alle Blöcke sind `F33f`_`[Closures`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Closure_(Funktion)]`_`f, sie speichern also z. B. den Zustand lokaler Variablen, wenn sie innerhalb des Blocks dauerhaft benötigt werden.
>>>Mixins
Ruby beherrscht bewusst keine Mehrfachvererbung, bietet stattdessen aber ein Konzept namens `F33f`_`[Mixin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mixin]`_`f (deutsch: Beimischung). Mixins sind Sammlungen von Methoden, die beliebigen Klassen `*beigemischt`* werden können. Eine Klasse kann beliebig viele Mixins beinhalten. Mixins werden in der Vererbungshierarchie zwischen Klasse und Superklasse in der Reihenfolge eingehängt, in der sie geschrieben wurden. Alternativ ist es auch möglich, Mixins vor die eigentliche Klasse zu hängen (u. a. hilfreich für `F33f`_`[Aspektorientierte Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Aspektorientierte_Programmierung]`_`f). Um Mixins zu definieren, werden in Ruby Module benutzt, das sind quasi Klassen (d. h. Sammlungen von Methoden) die nicht instanziiert werden können und `F33f`_`[Namensräume`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensraum]`_`f in einem.
`B100`F9d9class Tier`f`b
`B100`F9d9 def sagt`f`b
`B100`F9d9 puts "#{self.class} sagt nichts" # "text#{logik}text" ist Rubys Textinterpolation`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9module KannSchwimmen # Module, d. h. KannSchwimmen.new geht nicht`f`b
`B100`F9d9 def schwimmt`f`b
`B100`F9d9 puts "#{self.class} schwimmt" # self gibt die Instanz zurück,`f`b
`B100`F9d9 end # jedes Objekt hat eine Methode .class, die das Klassenobjekt zurückgibt`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9module KannNichtSchwimmen`f`b
`B100`F9d9 def schwimmt`f`b
`B100`F9d9 puts "#{self.class} geht unter"`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9class Fisch < Tier # Vererbung wird durch den Kleiner-Als-Operator gekennzeichnet`f`b
`B100`F9d9 include KannSchwimmen # füge KannSchwimmen zwischen Fisch und Tier ein`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9class Vogel < Tier`f`b
`B100`F9d9 include KannNichtSchwimmen`f`b
`B100`F9d9 def sagt # übliches Vererben, überdecke sagt-Methode von Tier`f`b
`B100`F9d9 puts "#{self.class}: Piep"`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9class Mensch < Tier`f`b
`B100`F9d9 include KannSchwimmen`f`b
`B100`F9d9 def sagt`f`b
`B100`F9d9 puts "#{self.class}: Ich kann mich besser ausdrücken"`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9class NichtSchwimmer < Mensch`f`b
`B100`F9d9 prepend KannNichtSchwimmen # hänge KannNichtSchwimmen vor NichtSchwimmer ein,`f`b
`B100`F9d9end # dh, überdecke die schwimmt-Methode`f`b
`B100`F9d9`f`b
`B100`F9d9fisch = Fisch.new`f`b
`B100`F9d9mensch = Mensch.new`f`b
`B100`F9d9vogel = Vogel.new`f`b
`B100`F9d9nicht_schwimmer = NichtSchwimmer.new`f`b
`B100`F9d9`f`b
`B100`F9d9fisch.sagt # => Fisch sagt nichts`f`b
`B100`F9d9vogel.sagt # => Vogel: Piep`f`b
`B100`F9d9mensch.sagt # => Mensch: Ich kann mich besser ausdrücken`f`b
`B100`F9d9nicht_schwimmer.sagt # => NichtSchwimmer: Ich kann mich besser ausdrücken`f`b
`B100`F9d9puts`f`b
`B100`F9d9fisch.schwimmt # => Fisch schwimmt`f`b
`B100`F9d9vogel.schwimmt # => Vogel geht unter`f`b
`B100`F9d9mensch.schwimmt # => Mensch schwimmt`f`b
`B100`F9d9nicht_schwimmer.schwimmt # => NichtSchwimmer geht unter`f`b
>>>>Offene Klassen
In Ruby sind alle Klassen offen, das heißt sämtliche Methoden können im späteren Programmverlauf ausgetauscht werden. Das gilt auch für alle ruby-internen Klassen. Um Methoden zu überschreiben, muss lediglich eine neue Klasse mit demselben Namen wie die zu überschreibende Klasse angelegt werden. Ruby tauscht dann die neu definierten Methoden aus oder fügt sie hinzu. Diese Technik ist sehr mächtig, ermöglicht aber auch schwer auffindbare Fehler, besonders in größeren Projekten. Aus diesem Grund wird sie auch leicht abwertend `*Monkey-Patching`* genannt. Etwas Abhilfe zu den auftretenden Problemen schaffen `*Refinements`*, eine Möglichkeit die Überschreibungen lokal einzuschränken. Die zuvor vorgestellte Methode, Module den gewünschten Klassen vorzuhängen `*(prepend)`*, ist meist die sichere Variante (und bietet außerdem die Möglichkeit die überdeckte Methode direkt aufzurufen).
`B100`F9d9class Numeric # ruby-interne Klasse`f`b
`B100`F9d9 def inverse # neue Methode, berechne den Kehrwert`f`b
`B100`F9d9 1.0 / self`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d95.inverse # => 0.2`f`b
>>>Domänenspezifische Sprache
Ruby wird gerne benutzt zum Erzeugen von `F33f`_`[domänenspezifischen Sprachen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Domänenspezifische_Sprache]`_`f. Das sind Textbausteine, die weniger wie Programmcode aussehen, sondern mehr wie eine `F33f`_`[Auszeichnungssprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Auszeichnungssprache]`_`f, in Wirklichkeit aber normaler Ruby-Code sind. Möglich macht das zum einen die flexible Schreibweise von Ruby, bspw. sind Klammern hinter Methodenaufrufen oder Semikola am Ende der Zeile optional. Zum anderen bietet Ruby viele Möglichkeiten zur `F33f`_`[Metaprogrammierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Metaprogrammierung]`_`f, die es möglich machen, redundante Ausdrücke verschwinden zu lassen und hinter den Kulissen das Programm zu verändern. Hier als Beispiel die Konfiguration einer Testfabrik für `*FactoryBot`*:
`B100`F9d9FactoryBot.define do`f`b
`B100`F9d9 factory :user do`f`b
`B100`F9d9 first_name "Max"`f`b
`B100`F9d9 last_name "Mustermann"`f`b
`B100`F9d9 admin false`f`b
`B100`F9d9 end`f`b
`B100`F9d9 factory :admin, class: User do`f`b
`B100`F9d9 first_name "Admin"`f`b
`B100`F9d9 last_name "Root"`f`b
`B100`F9d9 admin true`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
>>>Mächtige Standardbibliothek
Die Kern-Klassen (String, Integer, Float, Array, Hash, Range, Regexp) bringen eine Fülle an Methoden mit, die in jedem Rubyprogramm sofort verwendet werden können. Insbesondere durch die häufige Nutzung von Blöcken können mit diesen Methoden lange Programme auf wenige Zeilen reduziert werden, weshalb sich Ruby gut zum Zeigen von `F33f`_`[Proof of Concepts`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Proof_of_Concept]`_`f eignet. Bemerkenswert ist das Modul `*Enumerable`*, welches viele Konzepte der funktionalen Programmierung direkt in den Ruby-Kern bringt. `*Enumerable`* kann in jedes Objekt eingebunden werden, welches einen iterierbaren Container darstellt und die Methode `*each`* implementiert, bspw. die Klassen Array, Hash und Range. For-Schleifen sind in Ruby deshalb meist unnötig. Die im Folgenden gezeigten Methoden `*reduce`*, `*count`*, `*sort_by`*, `*each_slice`* und `*map`* sind alles Methoden aus `*Enumerable`* und können somit selbst erstellten Klassen leicht hinzugefügt werden.
`B100`F9d9# summiere die zahlen 1 bis 100 (ohne Summenformel), reduce entspricht fold aus der funktionalen Programmierung`f`b
`B100`F9d9(1..100).reduce{|counter,number| counter + number} # (1..100).sum geht auch`f`b
`B100`F9d9# Array aus den Zahlen von 0 bis 30 in 5er Schritten`f`b
`B100`F9d9(0..30).step(5).to_a`f`b
`B100`F9d9# Anzahl der Zeilen einer Datei die leer sind (ohne die Datei komplett in den Arbeitsspeicher zu laden)`f`b
`B100`F9d9IO.foreach("Dateiname").count{|line| line =~ /^\\s*$/}`f`b
`B100`F9d9# Sortiere Array nach Länge der Nachnamen`f`b
`B100`F9d9["Max Mustermann", "John Doe", "Tarou Yamada"].sort_by{|name| name.split.last.length}`f`b
`B100`F9d9# Schreibe jedes dritte Wort im Satz in Großbuchstaben`f`b
`B100`F9d9"Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.".split.each_slice(3).map{|drei_wörter| drei_wörter.last.upcase!; drei_wörter}.flatten.join(" ")`f`b
Zusätzlich zu den integrierten Modulen wird Ruby standardmäßig mit vielen Modulen ausgeliefert. Bspw. sind Unterstützung für `F33f`_`[JSON`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JSON]`_`f, `F33f`_`[YAML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=YAML]`_`f, `F33f`_`[HTTP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=HTTP]`_`f, Benchmarks, Primzahlen, sichere Zufallszahlen, `F33f`_`[OpenSSL`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenSSL]`_`f und Logging sofort vorhanden.
>>>Metaprogrammierung
Ruby bietet weitreichende Möglichkeiten zu `F33f`_`[Metaprogrammierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Metaprogrammierung]`_`f an. Damit ist es z. B. möglich, Methoden zu generieren, Instanzvariablen auszutauschen, die Vererbungshierarchie zu verändern oder Konstanten zu bearbeiten. Die Syntax zu verändern oder weitere Operatoren hinzuzufügen geht allerdings nicht. Hier sei als Beispiel eine Methode aufgeführt, Setter und Getter automatisch zu erzeugen (unter den Namen `*attr_reader`*, `*attr_writer`*, `*attr_accessor`* bereits im Standard enthalten).
`B100`F9d9class Object # Monkey-Patching aller Klassen`f`b
`B100`F9d9 def self.getter *args # self ist hier Object, es wird eine Klassenmethode erzeugt`f`b
`B100`F9d9 args.each do |arg| # es wird durch alle Parameter iteriert`f`b
`B100`F9d9 define_method arg do # define_method(arg){block} erzeugt eine neue Methode des Namens arg mit dem Inhalt block`f`b
`B100`F9d9 instance_variable_get("@#{arg}".to_sym) # instance_variable get gibt den Wert der Instanzvariablen des übergeben Namens zurück`f`b
`B100`F9d9 end # \\- "@#{arg}" hängt ein @ vor den Inhalt von arg, to_sym wandelt den String um in ein Symbol`f`b
`B100`F9d9 end`f`b
`B100`F9d9 end`f`b
`B100`F9d9 def self.setter *args # *args packt alle Parameter in ein Array namens args`f`b
`B100`F9d9 args.each do |arg|`f`b
`B100`F9d9 define_method :"#{arg}=" do |new_value| # define_method übergibt dem Block die übergeben Parameter`f`b
`B100`F9d9 instance_variable_set("@#{arg}".to_sym, new_value) # \\- setter-methoden enden mit einem =`f`b
`B100`F9d9 end`f`b
`B100`F9d9 end`f`b
`B100`F9d9 end`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9class PaarMit2`f`b
`B100`F9d9 def initialize links # Konstruktor`f`b
`B100`F9d9 @links = links # Instanzvariablen werden bei Erwähnung in einer beliebigen Methode automatisch erzeugt.`f`b
`B100`F9d9 @rechts = 2`f`b
`B100`F9d9 end`f`b
`B100`F9d9 getter :links, :rechts`f`b
`B100`F9d9 setter :links`f`b
`B100`F9d9end`f`b
`B100`F9d9`f`b
`B100`F9d9paar = PaarMit2.new(4) # new ruft immer den Konstruktor auf`f`b
`B100`F9d9paar.links # => 4`f`b
`B100`F9d9paar.rechts # => 2`f`b
`B100`F9d9paar.links = 9 # => 9`f`b
`B100`F9d9paar.links # => 9`f`b
`B100`F9d9paar.rechts = 8 # => Fehler: NoMethodError (undefined method \`rechts=')`f`b
Diese Techniken eignen sich auch gut zum Debuggen von Anwendungen oder zum Analysieren schlecht dokumentierter Anwendungen oder Bibliotheken. Bspw. antwortet jedes Objekt beim Aufruf der Methode `B100`F9d9methods`f`b mit einer Liste aller seiner Methoden, `B100`F9d9instance_variables`f`b gibt eine Liste aller Instanzvariablen zurück.
>>>Integration in Unix
Ruby bietet sich, ähnlich wie `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f, an, direkt in die `F33f`_`[Pipeline`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Pipe_(Informatik)]`_`f der Unix-Shell integriert zu werden. Möglich machen das Kommandozeilenparameter des Rubyinterpreters, mit denen man Programmlogik und übliches Programmverhalten definieren kann (üblicherweise die gleiche Operation auf jede Zeile anzuwenden). Ruby erweitert die Standard-Unixwerkzeuge mit fortgeschrittenen Methoden zur Textanalyse und Textverarbeitung.
Weiterhin bietet Ruby auch die Möglichkeit, innerhalb eines Programms bequem Prozesse zu starten, deren Eingabe zu steuern und Ausgabe und Rückgabewerte auszulesen. Code innerhalb `*\`\``* wird direkt an die Unix-Shell übergeben. Bspw. speichert der Befehl `B100`F9d9os_string = \`uname -a\``f`b den Betriebssystemnamen direkt in eine Rubyvariablen. Der Rückgabewert des letzten Programmaufrufs wird analog zur Shell automatisch in der globalen Variablen `B100`F9d9$?`f`b gespeichert. Auch Signalbehandlung, Sockets und Threads werden ohne zusätzliche Bibliotheken direkt vom Sprachkern unterstützt. Zum Beschleunigen der Verarbeitung gibt es in Ruby ein Modul namens `*FileUtils`*, das viel der Funktionalität vieler Unix-Dateiverwaltungsprogramme (`*rm`*, `*cp`*, `*chmod`*) direkt in Ruby abbildet.
>>>Syntax und Grundlagen
>>>>Namenskonvention
Ruby folgt der üblichen Konvention für Methoden- und Variablennamen, ein Name muss mit einem Kleinbuchstaben oder Unterstrich beginnen, dann dürfen beliebige Buchstaben (nach `F33f`_`[Unicode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Unicode]`_`f), Ziffern und Unterstriche folgen. Methoden dürfen zusätzlich mit einem Ausrufe- oder Fragezeichen enden. Nach der üblichen Konvention dient Ersteres als Hinweis, dass diese Methode eine schärfere Version der gleichen Methode ohne Ausrufezeichen ist (verändert den Zustand des Objekts, wirft Fehler, …), Letzteres bedeutet, dass die Funktion ein `*Boolean`* zurückgibt (true oder false). Fängt ein Variablenname mit einem Großbuchstaben an, so ist es eine Konstante. Variablen können zusätzlich mit einem Sonderzeichen anfangen, welches den Gültigkeitsbereich beschreibt.
>>>>Variablenbezeichner
Ruby unterscheidet fünf Gültigkeitsbereiche:
• Normalerweise ist eine Variable lokal innerhalb des umgebenden Blocks oder der umgebenden Methode gültig.
• Ein `B100`F9d9@`f`b vor Variablen deklariert Instanzvariable, sie werden dann dauerhaft der `F33f`_`[Instanz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f zugeordnet und sind nur in dieser sichtbar. Auf Instanzvariablen kann von außen nur über Methoden zugegriffen werden. Zugriff auf nicht vorhandene Instanzvariablen werfen keinen Fehler, sondern geben `*nil`* zurück
• Ein vorangestelltes `B100`F9d9@@`f`b macht Variablen zu Klassenvariablen, die zur umgebenden Klasse gehören.
• Mit `B100`F9d9$`f`b werden Variablen global und sind damit im gesamten Programm sichtbar.
• Der Gültigkeitsbereich für Konstanten richtet sich nach der lokalen Verschachtelungstiefe und kann mit `B100`F9d9::`f`b spezifiziert werden
>>>>Methodenaufrufe und Ausdrücke
In Ruby werden Methodenaufrufe nicht zwingend mit nachfolgenden Klammern gekennzeichnet. `B100`F9d9gets.chomp`f`b ist also äquivalent zu `B100`F9d9gets().chomp()`f`b. Wenn Methoden Parameter benötigen, müssen diese in Klammern gesetzt werden, wenn auf dem Ergebnis eine weitere Operation ausgeführt werden soll. `B100`F9d9"a,b,c".split ","`f`bist ok, `B100`F9d9"a,b,c".split(",").join(" ")`f`b benötigt aber zwingend das erste Klammernpaar. Da Klammern auch zur Gruppierung eingesetzt werden, sollte bei erwünschtem Methodenaufruf niemals ein Leerzeichen zwischen Methodenname und Klammer gesetzt werden. So wird `B100`F9d9[1,2].join␣("|") * 2`f`b als `B100`F9d9[1,2].join(("|") * 2)`f`b interpretiert, mit dem Ergebnis `B100`F9d9"1||2"`f`b. `B100`F9d9[1,2].join("|") * 2`f`b hingegen wird als `B100`F9d9([1,2].join("|")) * 2`f`binterpretiert, und hat damit das Ergebnis `B100`F9d9"1|21|2"`f`b.
Jede Anweisung bildet einen Ausdruck, der einer Variablen zugewiesen werden kann. Einzelne Anweisungen werden durch Zeilenumbrüche oder Semikolons getrennt. Der letzte Ausdruck innerhalb einer Methode bildet automatisch deren Rückgabewert. Es kann aber auch schon vorher mit Schlüsselwort `*return`* frühzeitig zurückgesprungen werden.
>>>>Datentypen
Die elementaren Datentypen besitzen bequemere Konstruktoren als das übliche `B100`F9d9Klasse.new`f`b
• String: `B100`F9d9"Text"`f`b, `B100`F9d9'Text'`f`b oder `B100`F9d9%{Text}`f`b `*Text`*
• Integer: `B100`F9d93`f`b (Zehnersystem), `B100`F9d90775`f`b oder `B100`F9d90o775`f`b (Oktalsystem), `B100`F9d90xFF`f`b (Hexadezimalsystem) `B100`F9d90b1001`f`b (Binärsystem) `*Ganzzahl (unbeschränkte Größe)`*
• Float: `B100`F9d93.0`f`b `*Fließkommazahl (beschränkte Genauigkeit)`*
• Rational: `B100`F9d91/2r`f`b `*Rationale Zahl`*
• Complex: `B100`F9d91 + 1i`f`b `*Komplexe Zahl`*
• Array: `B100`F9d9[1,2,3]`f`b `*Auflistung, kann beliebige verschiedene Datentypen enthalten`*
• Hash: `B100`F9d9{ 1 => "eins", 2 => "zwei" }`f`b `*Zuordnung, ordnet jedem Wert vor den Pfeilen (Schlüssel) genau einen Wert zu`*
• Regexp: `B100`F9d9/\\A(eins|zwei)\\z/`f`b oder `B100`F9d9%r{\\A(eins|zwei)\\z}`f`b `*`F33f`_`[Regulärer Ausdruck`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Regulärer_Ausdruck]`_`f`*
• Range: `B100`F9d91..3`f`b oder `B100`F9d91...4`f`b (rechtes Element ausschließend) `*Intervall`*
• Symbol: `B100`F9d9:zeichen`f`b `*Symbol, siehe unten`*
>>>>Dynamische Strings
Zeichenketten sind in Ruby standardmäßig veränderbar, d. h., ein String-Objekt kann seinen Wert zur Laufzeit verändern. `B100`F9d9text = "Felar"; text[2..3] = "hle"; puts text`f`b verändert den Wert von `B100`F9d9text`f`b direkt (und gibt `*Fehler`* aus). Viele String-Methoden gibt es sowohl in einer verändernden Variante und in einer Variante, die ein neues String-Objekt erzeugt.
`B100`F9d9a = "ABC"`f`b
`B100`F9d9b = a.downcase`f`b
`B100`F9d9puts a, b # => ABC abc`f`b
`B100`F9d9a.downcase!`f`b
`B100`F9d9puts a, b # => abc abc`f`b
Strings können wie jedes Ruby-Objekt durch Aufruf der Methode `B100`F9d9freeze`f`b eingefroren werden (bspw. `B100`F9d9"ABC".freeze`f`b) und sind danach unveränderbar.
>>>>Symbole
Dieser etwas ungewöhnliche und auch umstrittene Datentyp ist in eine Art Mischung aus Integer und String. Er dient primär als Merkhilfe für Schlüssel von Hashes, da hier dynamische Strings unpraktisch sind und Integer wenig Speicher benötigen. Symbole besitzen die Textmanipulationsmethoden von String nicht, können aber jederzeit in Strings umgewandelt werden. Werden Symbole in Hashes als Schlüssel verwendet, kann eine vereinfachte Schreibweise verwendet werden. Statt `B100`F9d9{ :a => 1, :b => 2 }`f`b kann auch `B100`F9d9{ a: 1, b: 2 }`f`b geschrieben werden. Ruby-intern werden Symbole auch häufig verwendet, so können Methoden auch mit ihrem Symbolnamen aufgerufen werden: `B100`F9d91 < 4`f`b kann auch als `B100`F9d91.send(:<, 4)`f`b geschrieben werden. Einfache Blöcke, die nur eine Methode des übergebenen Objekts aufrufen, können mit Symbolen vereinfacht geschrieben werden, wobei das Symbol die aufzurufende Methode bezeichnet. `B100`F9d9[1,2,3].map{|i| i.to_s}`f`b kann auch als `B100`F9d9[1,2,3].map(&:to_s)`f`b geschrieben werden (& wandelt das Symbol in einen Block um).
>>>>Wahrheitswerte
In Ruby gibt es drei verschiedene Wahrheitswerte, `B100`F9d9true`f`b, `B100`F9d9false`f`b und `B100`F9d9nil`f`b. Nil steht hierbei für ein fehlendes Ergebnis und wird wie false als `*Falsch`* ausgewertet. True und `!alle`! anderen Objekte werden als `*Wahr`* ausgewertet. `B100`F9d9puts "Ja!" if 0`f`b evaluiert also zu `*Wahr`*, „Ja!“ wird ausgegeben.
>>>>Fehlerbehandlung
In den meisten Programmiersprachen muss der auf Fehler zu überprüfende Programmteil explizit markiert werden (meist durch die Schlüsselwörter `*try`* und `*catch`*), in Ruby muss für die üblichsten Fälle (der Programmteil umfasst die gesamte Methode oder den gesamten Block) kein eigener Bereich markiert werden. Wenn eine Abgrenzung erforderlich sein sollte, kann der Bereich mit `*begin`* und `*end`* markiert werden.
`B100`F9d9def gib_summe_aus arg1, arg2`f`b
`B100`F9d9 # Methodenlogik`f`b
`B100`F9d9 unless arg1.is_a?(Numeric) && arg2.is_a?(Numeric)`f`b
`B100`F9d9 raise ArgumentError.new("Bitte nur Zahlen eingeben") # raise wirft Fehler`f`b
`B100`F9d9 end`f`b
`B100`F9d9 puts arg1 + arg2`f`b
`B100`F9d9rescue ArgumentError => e # Fange ArgumentError ab`f`b
`B100`F9d9 puts "Es ist ein Fehler bei der Parameterübergabe aufgetreten"`f`b
`B100`F9d9rescue => e # Fange alle weiteren Fehler ab`f`b
`B100`F9d9 puts e.message`f`b
`B100`F9d9ensure # wird auf jeden Fall ausgeführt`f`b
`B100`F9d9 puts 'Methodenende'`f`b
`B100`F9d9end`f`b
>>>>Alternative Bedingungen / Schleifen
Bedingungen und Schleifen bieten sowohl eine Postfixnotation als auch ein eigenes Schlüsselwort für das Inverse (inspiriert von `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f).
`B100`F9d9a = 5`f`b
`B100`F9d9if a < 10; puts a; end`f`b
`B100`F9d9puts a if a < 10 # Suffixform`f`b
`B100`F9d9unless a >= 10; puts a; end # Invers`f`b
`B100`F9d9puts a unless a >= 10 # Invers + Suffixform`f`b
`B100`F9d9`f`b
`B100`F9d9while a < 10; puts a; a += 1; end`f`b
`B100`F9d9(puts a; a+=1) while a < 20 # Suffixform`f`b
`B100`F9d9until a >= 30; puts a; a += 1; end # Invers`f`b
`B100`F9d9(puts a; a +=1) until a >= 40 # Invers + Suffixform`f`b
>>>>Reguläre Ausdrücke
Reguläre Ausdrücke sind in Ruby direkt im Sprachkern enthalten. Ruby benutzt eine eigene Regex-Engine namens `*Onigmo`*, deren Syntax und Funktionsumfang zum größten Teil kompatibel mit `F33f`_`[PCRE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PCRE]`_`f ist. Zusätzlich ist es möglich, Rubyvariablen direkt in reguläre Ausdrücke zu interpolieren und beliebige Programmlogik durch Blöcke beim Suchen und Ersetzen zu verwenden. Bspw. addiert folgender Befehl alle Zahlen in einem Text um eins: `B100`F9d9puts "test, 1, 2, 3".gsub(/(\\d+)/){|zahl| zahl.to_i + 1} # => test, 2, 3, 4`f`b
>>>>Konstanten
Konstanten sind in Ruby alle Variablen, die mit einem Großbuchstaben anfangen. Alle Klassen und Module sind somit Konstanten. Das Besondere an Konstanten in Ruby ist ihre Verschachtelung. Konstanten innerhalb von Konstanten können mittels `B100`F9d9::`f`b aufgerufen werden und unterliegen keinen Zugriffsrechten (wie etwa Methoden oder Instanzvariablen). Deswegen können Module als Namensräume benutzt werden, alle Variablen bleiben darin versteckt, auf alle Konstanten (wie bspw. Klassen) kann über den Modulnamen qualifiziert zugegriffen werden (bspw. `B100`F9d9MeinModul::MeineKlasse.new`f`b).
>>Bestandteile
>>>Interaktive Ruby-Shell
`F33f`_`[Interactive Ruby (irb)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interactive_Ruby_Shell]`_`f ist eine `F33f`_`[Read-Eval-Print Loop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommandozeileninterpreter]`_`f (REPL), mit welcher der Anwender interaktiv Ruby programmieren kann. Irb wird mit dem Ruby-Interpreter ausgeliefert und kann zum Analysieren und Testen eingesetzt werden:
`B100`F9d9irb(main):001:0> (5 + 7) * 2`f`b
`B100`F9d9=> 24`f`b
`B100`F9d9irb(main):002:0> ((5 + 7) * 2).to_s.reverse`f`b
`B100`F9d9=> "42"`f`b
`B100`F9d9irb(main):003:0> "Ein Beispielstring".size`f`b
`B100`F9d9=> 18`f`b
Als Alternative zu Irb gibt es `!Pry`!, eine REPL, welche weitaus tiefgreifendere Möglichkeiten zur `F33f`_`[Introspektion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Reflexion_(Programmierung)]`_`f und zum `F33f`_`[Debuggen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Debugger]`_`f mitbringt.
>>>RDoc und ri
RDoc ist ein `F33f`_`[Software-Dokumentationswerkzeug`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Software-Dokumentationswerkzeug]`_`f, welches aus Ruby- und C-Quelltexten automatisch `F33f`_`[HTML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hypertext_Markup_Language]`_`f-Dokumentationsdateien erstellt. Weiterhin wird eine Datenbank aufgebaut, die mit dem Tool ri durchsucht werden kann. RDoc und ri sind Bestandteil der Standarddistribution und werden zusammen mit dem Interpreter ausgeliefert.
>>>Rake
`F33f`_`[Rake`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rake_(Software)]`_`f steht für Ruby-Make und ist eine Alternative zu `F33f`_`[Make`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Make]`_`f aus `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f. Da es in Ruby keine Kompilationsphase gibt, dienen Rakefiles zum Automatisieren repetitiver Aufgaben, bspw. dem Generieren von Dokumentation, dem Upload von Dateien oder dem Packen von Projekten. Rake kann wie Make Abhängigkeiten auflösen, wenn für Aufgabe B erst Aufgabe A erfüllt sein muss, so führt Rake automatisch Aufgabe A aus. Rake ist eine `F33f`_`[domänenspezifische Sprache`#dom-nenspezifische-sprache]`_`f, d. h., es lässt sich bequem wie eine Auszeichnungssprache lesen, bietet aber die vollen Möglichkeiten die Ruby bietet.
>>>Paketverwaltung
Ruby-Bibliotheken werden üblicherweise als `F33f`_`[Gems (RubyGems)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=RubyGems]`_`f gepackt und auf rubygems.org, dem zentralen Gem-Register, veröffentlicht. RubyGems löst bei der Installation oder bei Updates die im Paket angegebenen Abhängigkeiten eigenständig rekursiv auf und bietet dabei sogar die Möglichkeit Pakete gleichzeitig in unterschiedlichen Versionen bereitzustellen. Seit Ruby 1.9 ist Rubygems Bestandteil der Standardbibliothek von Ruby. Heute wird es meist zusammen mit Bundler benutzt (ebenfalls Teil der Standardbibliothek, seit Ruby 2.6), einem Programm welches Schnappschüsse aus einer Kollektion von Gems erstellt und diese Anordnung auf anderen Maschinen (oder andern Projektordnern) wiederherstellen kann.
>>Implementierungen
>>>Referenzimplementierung
Die Referenzimplementierung von Ruby wurde von Yukihiro „Matz“ Matsumoto als `F33f`_`[Interpreter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interpreter]`_`f in C entworfen. Dieser wird meist als `!MRI`! `*(Matz’s Ruby Interpreter)`* oder auch als `!CRuby`! bezeichnet und ist derzeit am weitesten verbreitet. Den Kern bildet `!`F33f`_`[YARV`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=YARV]`_`f`! `*(Yet Another Ruby VM)`*, eine `F33f`_`[virtuelle Maschine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Virtuelle_Maschine]`_`f. Statt ein Rubyprogramm direkt auszuführen, wird es zunächst in `F33f`_`[Bytecode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bytecode]`_`f übersetzt und dann von YARV interpretiert, wodurch sich ein Geschwindigkeitsvorteil ergibt. Weiterhin enthält diese Version eine leistungsstarke `F33f`_`[Regexp`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Regulärer_Ausdruck]`_`f-Maschine namens Oniguruma und unterstützt Multibyte-Zeichensätze wie `F33f`_`[UTF-8`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=UTF-8]`_`f.
Der offizielle Interpreter läuft auf den folgenden Betriebssystemen:
• `F33f`_`[POSIX`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Portable_Operating_System_Interface]`_`f-kompatible Systeme (u. a. `F33f`_`[Linux`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linux]`_`f, `F33f`_`[BSD`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Berkeley_Software_Distribution]`_`f und `F33f`_`[macOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MacOS]`_`f)
• `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows]`_`f (aktuelle Versionen benötigen `F33f`_`[MSYS2`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MSYS2]`_`f und laufen demnach ab `F33f`_`[Vista`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows_Vista]`_`f)
>>>Alternative Implementierungen
Es gibt zahlreiche alternative Ruby-Implementierungen mit unterschiedlichem Umfang und Zielen:
• `!`F33f`_`[JRuby`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JRuby]`_`f`! ist eine Implementierung des Ruby-Interpreters in `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f mit dem Ziel, Ruby nahtlos in die `F33f`_`[Java-Plattform`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java-Plattform]`_`f zu integrieren. JRuby ist fast vollständig kompatibel zu Ruby 3.1. JRuby ist zudem kompatibel zu einigen Ruby-Erweiterungen von Rubinius (Foreign Function Interface, Multi-VM-API), allerdings nicht mit `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f-Erweiterungen von CRuby.
• `!Mruby`!`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f] ist eine weitere Ruby-Implementierung erschaffen vom Ruby-Schöpfer Yukihiro Matsumoto. Mruby ist eine auf `F33f`_`[eingebettete Systeme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eingebettetes_System]`_`f zugeschnittene Version von Ruby, welche sich durch geringen Speicherbedarf und hohe Modularisierung auszeichnet. Mruby stellt nicht die vollständige Funktionalität von CRuby bereit. Mruby kann den Quellcode in Bytecode übersetzen, welcher dann ohne `F33f`_`[Kompilationsschritt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f interpretiert oder in `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f-Programme eingebettet werden kann.
• `!Opal`!`:cite-ref-10[`F5bf`_`[10`#cite-note-10]`_`f] ist ein Compiler von Ruby nach `F33f`_`[JavaScript`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JavaScript]`_`f. Es handelt sich um eine Implementierung der Ruby-Corelib und Stdlib sowie den zugehörigen Gems. Mit Opal lassen sich clientseitige Webanwendungen in Ruby realisieren. Es gibt einige Einschränkungen, die der Umsetzung nach JavaScript geschuldet sind.
• `!TruffleRuby`!`:cite-ref-11[`F5bf`_`[11`#cite-note-11]`_`f] ist eine Ruby-Implementierung, die auf der `F33f`_`[GraalVM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GraalVM]`_`f läuft. Ziel der Implementierung ist es, die Vorteile der GraalVM mittels Ruby nutzbar zu machen. Diese sind Geschwindigkeit (Start- und Laufzeit), Parallelisierung und das `F33f`_`[kontrollierte Ausführen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sandbox]`_`f von C-Erweiterungen. TruffleRuby ist `F33f`_`[open-source`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open-source]`_`f und wird maßgeblich von `F33f`_`[Oracle`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Oracle]`_`f entwickelt.
• `!Fullstaqruby`!`:cite-ref-12[`F5bf`_`[12`#cite-note-12]`_`f] ist keine eigene Implementierung, sondern eine spezielle Distribution von MRI, die für den Einsatz auf Webservern optimiert wurde. Im Vergleich zur Referenzimplementierung verspricht Fullstaqruby eine bessere Performance bei geringerem Speicherverbrauch.
Historische Ruby-Implementierungen:
• `!`F33f`_`[Rubinius`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rubinius]`_`f`! ist eine von `F33f`_`[Smalltalk-80`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Smalltalk_(Programmiersprache)]`_`f inspirierte Implementierung. Abgesehen von der virtuellen Maschine ist Rubinius vollständig in Ruby geschrieben. Rubinius ist nahezu vollständig kompatibel zu Ruby 2.3. Rubinius nutzt die `F33f`_`[Low Level Virtual Machine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Low_Level_Virtual_Machine]`_`f (LLVM) und ist kompatibel mit `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f-Erweiterungen der Referenzimplementierung. Seit 2020 gibt es keine Bewegung mehr im Projekt und die Projektwebseite ist mittlerweile leer.
• `!IronRuby`!`:cite-ref-13[`F5bf`_`[13`#cite-note-13]`_`f] ist eine Implementierung, die Ruby ins `F33f`_`[.NET Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.NET_Framework]`_`f integriert und in `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f implementiert ist. Das Projekt ist seit 13. März 2011 inaktiv und wird nicht mehr weiterentwickelt.
• `!Cardinal`!, ein Interpreter für die virtuelle Maschine `F33f`_`[Parrot`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parrot]`_`f. Das Projekt ist seit Juni 2013 inaktiv.
• `!MagLev`! ist eine Implementierung des Unternehmens Gemstone für deren `F33f`_`[proprietäre`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Proprietär]`_`f Smalltalk VM. Das Projekt ist seit 2015 inaktiv.
• `!MacRuby`!`:cite-ref-14[`F5bf`_`[14`#cite-note-14]`_`f] ist eine Implementierung in `F33f`_`[Objective-C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objective-C]`_`f von `F33f`_`[Apple`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Apple]`_`f, die bis Version 0.4, wie Ruby 1.9, YARV nutzt, ab Version 0.5 allerdings, wie `F33f`_`[Rubinius`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rubinius]`_`f, auf die `F33f`_`[LLVM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=LLVM]`_`f setzt. Die Weiterentwicklung wurde mit dem 5. Januar 2015 eingestellt.
• `!Ruby Enterprise Edition`!`:cite-ref-15[`F5bf`_`[15`#cite-note-15]`_`f] ist eine modifizierte Version der Referenzimplementierung, bei der im Wesentlichen der `F33f`_`[Garbage Collector`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Garbage_Collector]`_`f neu implementiert wurde. REE ist lediglich mit Ruby 1.8 kompatibel, die aktuellste Version stammt aus dem Jahr 2012.
Die Kompatibilität zur Referenzimplementierung wird durch das RubySpec-Projekt überprüft. Es stellt dabei sowohl eine `F33f`_`[Testsuite`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Testsuite_(Webapplikation)]`_`f als auch eine `F33f`_`[Spezifikation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Spezifikation]`_`f für Ruby dar. RubySpec war ursprünglich ein Teil von Rubinius, wurde aber ausgelagert und danach auch von einer Vielzahl anderer Entwickler vorangetrieben. Es wird in vielen Ruby-Implementierungen verwendet.
Mit Hilfe eines Versionsmanagers, wie beispielsweise RVM (Ruby Version Manager)`:cite-ref-16[`F5bf`_`[16`#cite-note-16]`_`f] oder Rbenv`:cite-ref-17[`F5bf`_`[17`#cite-note-17]`_`f], besteht die Möglichkeit, mehrere Ruby-Versionen parallel zu betreiben.
Ein wichtiges Merkmal der Implementierungen ist, ob sie in der Lage sind, `F33f`_`[Ruby on Rails`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ruby_on_Rails]`_`f auszuführen. Derzeit können dies neben der Referenzimplementierung nur JRuby`:cite-ref-18[`F5bf`_`[18`#cite-note-18]`_`f], Rubinius`:cite-ref-19[`F5bf`_`[19`#cite-note-19]`_`f] und TruffleRuby`:cite-ref-20[`F5bf`_`[20`#cite-note-20]`_`f].
>>Verbreitung und Einsatz
Ruby ist für alle gängigen Desktop-Betriebssysteme frei erhältlich, in den meisten Linux-Distributionen ist es in den mitgelieferten Paketquellen enthalten, unter macOS sogar vorinstalliert.
Größte Verbreitung findet Ruby im Einsatz als Webserver-Skriptsprache. Das verbreitetste Framework hierbei ist `F33f`_`[Ruby on Rails`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ruby_on_Rails]`_`f, wobei es aber zahlreiche Alternativen verschiedener Größen gibt (bspw. `F33f`_`[Sinatra`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sinatra_(Software)]`_`f und Hanami). Die Liste großer Railsprojekte ist lang, am bekanntesten sind möglicherweise kommerzielle Webseiten wie `F33f`_`[GitHub`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GitHub]`_`f, `F33f`_`[Airbnb`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Airbnb]`_`f oder `F33f`_`[Shopify`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Shopify]`_`f oder Gemeinschaftsprojekte wie `F33f`_`[Diaspora`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Diaspora_(Software)]`_`f, `F33f`_`[Redmine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Redmine]`_`f und `F33f`_`[Discourse`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Discourse_(Software)]`_`f. In Ruby geschriebene Webtechnologien wie `F33f`_`[Sass`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Sass_(Stylesheet-Sprache)]`_`f und `F33f`_`[Haml`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Haml]`_`f finden auch außerhalb des Ruby-Ökosystems Verwendung.
Weiter große Verbreitung findet Ruby als Skriptsprache zum Verwalten und Automatisieren von Serveraufgaben, angefangen als Ersatz für komplexere `F33f`_`[Bash`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Bash_(Shell)]`_`f-Skripte, als auch für größere Anwendungen, bspw. `F33f`_`[Puppet`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Puppet_(Software)]`_`f (Serverkonfiguration über das Netzwerk), `F33f`_`[Metasploit`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Metasploit]`_`f (`F33f`_`[Penetrationstests`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Penetrationstest_(Informatik)]`_`f), `F33f`_`[YaST`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=YaST]`_`f (`F33f`_`[OpenSUSE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=OpenSUSE]`_`f-Serveradministration) und `F33f`_`[Vagrant`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Vagrant_(Software)]`_`f (Verwaltung virtueller Maschinen).
Ruby wird wegen der flexiblen Syntax ebenfalls gerne als domänenspezifische Sprache benutzt. Mit `*mruby`* gibt es auch eine Ruby-Variante, die sich auf `F33f`_`[Eingebettete Systeme`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eingebettetes_System]`_`f spezialisiert. Vereinzelt wird Ruby auch als Skript-Sprache in Spielen verwendet, bspw. im `F33f`_`[RPG Maker`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=RPG_Maker]`_`f.
>>Kritik
Kritik an der Sprache wurde aus verschiedenen Gründen geübt:
• Da Variablen vor Gebrauch nicht deklariert werden müssen, können bei Tippfehlern unerwartete Laufzeitfehler auftreten. Statische Codeanalyse, welche mit Ruby 3.0 hinzugefügt wurde, kann einige dieser Probleme verhindern.
• `F33f`_`[Metaprogrammierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Metaprogrammierung]`_`f und Monkeypatching erlauben es einem Codestück, alle Klassen und Objekte des Prozesses, in dem es ausgeführt wird, zu ändern.`:cite-ref-21[`F5bf`_`[21`#cite-note-21]`_`f]
Auch an der Referenzimplementierung bemängeln Kritiker mehrere Aspekte:
• YARVs Global Interpreter Lock führt dazu, dass mehrere Threads eines Prozesses nicht gleichzeitig auf verschiedenen `F33f`_`[Prozessorkernen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozessorkern]`_`f ausgeführt werden können.`:cite-ref-22[`F5bf`_`[22`#cite-note-22]`_`f]`:cite-ref-23[`F5bf`_`[23`#cite-note-23]`_`f] Seit Ruby 3.0 gibt es ein alternatives System für Nebenläufigkeit, genannt `*Ractor`*, welches ohne GIL auskommt. Allerdings muss vorhandener Code dafür umgeschrieben werden.
>>Sonstiges
>>>Nutzungsbedingungen
Ruby ist eine `F33f`_`[freie Software`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Freie_Software]`_`f. Deshalb ist es kostenlos nutzbar und im `F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f verfügbar. Dadurch ergibt sich die Möglichkeit, die Sprache an seine eigenen Bedürfnisse anzupassen oder sie in eigene Programme einzubinden.
Der Interpreter und die Standardbibliothek von Ruby sind grundsätzlich unter den Bedingungen der `F33f`_`[2-clause BSD-Lizenz`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=BSD-Lizenz]`_`f nutzbar. Des Weiteren besteht die Möglichkeit, Ruby unter einer eigenen freien Lizenz zu verwenden.`:cite-ref-24[`F5bf`_`[24`#cite-note-24]`_`f] Die Ruby-Lizenz ist GPL-kompatibel und wird von der `F33f`_`[Free Software Foundation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Free_Software_Foundation]`_`f als „frei“ akzeptiert.`:cite-ref-25[`F5bf`_`[25`#cite-note-25]`_`f]
Ältere Versionen von Ruby (1.9.2 und früher) verwendeten anstatt der BSD-Lizenz die `F33f`_`[GPL V2`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GNU_General_Public_License]`_`f. Als Begründung für den Wechsel wurden Inkompatibilitäten der alten Lizenzierung mit der GPL V3 angeführt.`:cite-ref-26[`F5bf`_`[26`#cite-note-26]`_`f]`:cite-ref-27[`F5bf`_`[27`#cite-note-27]`_`f]
>>>RubyForge
RubyForge war eine `F33f`_`[öffentliche Softwareentwicklungsplattform`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Softwareentwicklungsplattform]`_`f für in Ruby geschriebene Softwareprojekte. Sie wurde im Jahr 2003 von Ruby Central gestartet, um der Ruby-Community eine Heimat für ihre `F33f`_`[Open-Source`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Open_Source]`_`f-Projekte zur Verfügung zu stellen.
Am 29. November 2009 wurden dort über 9.300 Projekte und mehr als 94.683 Benutzer geführt`:cite-ref-rubyforge-28-0[`F5bf`_`[28`#cite-note-rubyforge-28]`_`f], am 15. Mai 2014 wurde der Dienst schließlich eingestellt.`:cite-ref-29[`F5bf`_`[29`#cite-note-29]`_`f]
>>Literatur
`!Für Programmieranfänger`!
• Chris Pine: Learn to Program. 2. Auflage. The Pragmatic Bookshelf, Raleigh/Dallas 2009, ISBN 978-1-934356-36-4 (englisch, Kürzere Version kostenlos online).
`!Einstieg für Programmierer`!
• Peter Cooper: Beginning Ruby. From Novice to Professional. 3. Auflage. Apress, New York City 2016, ISBN 978-1-4842-1279-0 (englisch, Quellcode).
• Dave Thomas, Chad Fowler, Andy Hunt: Programming Ruby 1.9 & 2.0. 2. Auflage. The Pragmatic Bookshelf, Raleigh/Dallas 2013, ISBN 978-1-937785-49-9 (englisch, Errata, Quellcode).
`!Vertiefung für Programmierer`!
• David A. Black: The Well-Grounded Rubyist. 2. Auflage. Manning, Shelter Island 2014, ISBN 978-1-61729-169-2 (englisch, Errata, Quellcode).
• Hal Fulton, André Arko: The Ruby Way. Solutions and Techniques in Ruby Programming. 3. Auflage. Addison-Wesley, Upper Saddle River, u. a. 2015, ISBN 978-0-321-71463-3 (englisch, Auszug [PDF]).
`!Gesamtdarstellungen`!
• David Flanagan, Yukihiro Matsumoto: `*Die Programmiersprache Ruby`*. O’Reilly Media, 2008, ISBN 978-3-89721-874-1
`!Für Fortgeschrittene`!
• Lucas Carlson, Leonard Richardson: `*Ruby Cookbook`*. O’Reilly Media, 2. Auflage 2015, ISBN 1-4493-7371-2 (englisch)
• Pat Shaughnessy: `*Ruby Under a Microscope`*. No Starch Press, 1. Auflage 2013, ISBN 1-59327-527-7 (englisch)
• Russ Olsen: `*Eloquent Ruby`*. Addison-Wesley Professional, 2011, ISBN 978-0-321-58410-6 (englisch)
• Russ Olsen: `*Design Patterns in Ruby`*. Addison-Wesley Professional, 2007, ISBN 978-0-321-49045-2 (englisch)
>>Normen und Standards
• ISO/IEC 30170 (englisch; standardisiert Ruby auf über 317 Seiten). Erste Version April 2012.
>>Weblinks
Commons
: Ruby
– Sammlung von Bildern, Videos und Audiodateien
Wikibooks: Ruby-Programmierung
– Lern- und Lehrmaterialien
• Offizielle Website von Ruby
• Zusammenstellung von Tutorials zu Ruby
• Dokumentationssammlung zu Ruby (englisch)
• Linkkatalog zum Thema Ruby bei `*curlie.org`* (ehemals `F33f`_`[DMOZ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DMOZ]`_`f)
>>Einzelnachweise
`:cite-note-e0d9a819dcdfffc1-1`!1.`! www.ruby-lang.org.
`:cite-note-03a3180b7ac7d47d-2`!2.`! www.ruby-lang.org.
`:cite-note-3`!3.`! D Programming Language 1.0 , Intro. Digital Mars
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f iso.org
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f RubyConf: History of Ruby
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f Ein Interview mit dem Schöpfer von Ruby
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `*About Ruby.`* Abgerufen am 4. Oktober 2018.
`:cite-note-8`!8.`! `F0af`_`[↑`#cite-ref-8]`_`f `*Ruby 1.9 released.`* Abgerufen am 5. September 2020 (englisch).
`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `*Mruby: Projektwebseite.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-10`!10.`! `F0af`_`[↑`#cite-ref-10]`_`f `*Opal: Projektwebseite.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-11`!11.`! `F0af`_`[↑`#cite-ref-11]`_`f `*TruffleRuby: Eintrag zum Projekt im Handbuch der GraalVM.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-12`!12.`! `F0af`_`[↑`#cite-ref-12]`_`f `*Fullstaqruby: Projektwebseite.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-13`!13.`! `F0af`_`[↑`#cite-ref-13]`_`f `*Verwaiste Projektwebseite von Ironruby.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-14`!14.`! `F0af`_`[↑`#cite-ref-14]`_`f `*Verwaiste Projektwebseite von MagRuby.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-15`!15.`! `F0af`_`[↑`#cite-ref-15]`_`f `*Verwaiste Projektwebseite von Ruby Enterprise Edition.`* Abgerufen am 3. November 2022 (englisch).
`:cite-note-16`!16.`! `F0af`_`[↑`#cite-ref-16]`_`f `*RVM: Ruby Version Manager – RVM Ruby Version Manager - Dokumentation.`* Abgerufen am 4. Oktober 2018 (englisch).
`:cite-note-17`!17.`! `F0af`_`[↑`#cite-ref-17]`_`f `*rbenv/rbenv.`* Abgerufen am 4. Oktober 2018 (englisch).
`:cite-note-18`!18.`! `F0af`_`[↑`#cite-ref-18]`_`f `*JRuby Wiki.`* Abgerufen am 23. Februar 2017 (englisch).
`:cite-note-19`!19.`! `F0af`_`[↑`#cite-ref-19]`_`f Evan Phoenix: `*Rails on Rubinius.`* 17. Mai 2008, archiviert vom Original am 22. März 2016; abgerufen am 23. Februar 2017 (englisch).
`:cite-note-20`!20.`! `F0af`_`[↑`#cite-ref-20]`_`f Benoit Daloze: `*Running Rack and Rails Faster with TruffleRuby.`* 4. September 2020, abgerufen am 30. September 2021 (englisch).
`:cite-note-21`!21.`! `F0af`_`[↑`#cite-ref-21]`_`f Avdi Grimm: `*Monkeypatching is Destroying Ruby.`* 23. Februar 2008, abgerufen am 23. Februar 2017 (englisch).
`:cite-note-22`!22.`! `F0af`_`[↑`#cite-ref-22]`_`f infoq.com
`:cite-note-23`!23.`! `F0af`_`[↑`#cite-ref-23]`_`f igvita.com
`:cite-note-24`!24.`! `F0af`_`[↑`#cite-ref-24]`_`f `*Rubys Lizenzbedingungen.`* Abgerufen am 23. Februar 2017.
`:cite-note-25`!25.`! `F0af`_`[↑`#cite-ref-25]`_`f `*Liste der GPL-kompatiblen Lizenzen.`* Abgerufen am 23. Februar 2017.
`:cite-note-26`!26.`! `F0af`_`[↑`#cite-ref-26]`_`f `*Mailinglistendiskussion zum Lizenzwechsel.`* Archiviert vom Original am 11. Juni 2015; abgerufen am 8. Juli 2012.
`:cite-note-27`!27.`! `F0af`_`[↑`#cite-ref-27]`_`f `*Beschluss zum Lizenzwechsel auf dem Ruby Developers Meeting 2010.`* Abgerufen am 23. Februar 2017.
`:cite-note-rubyforge-28`!28.`! `F0af`_`[↑`#cite-ref-rubyforge-28-0]`_`f RubyForge (`F33f`_`[Memento`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webarchivierung]`_`f vom 31. Mai 2014 im `*`F33f`_`[Internet Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Internet_Archive]`_`f`*)
`:cite-note-29`!29.`! `F0af`_`[↑`#cite-ref-29]`_`f `*Twitter-Nachricht von Evan Phoenix.`* Abgerufen am 28. März 2014.
`c`F0af`_`[↑ Back to top`#top]`_`f`a